package youdu

import (
	"encoding/json"
	"fmt"
	"youdu/model"
)

const (
	API_PATH_USER_CREATE         string = "/cgi/user/create"
	API_PATH_USER_UPDATE         string = "/cgi/user/update"
	API_PATH_USER_UPDATE_POS     string = "/cgi/user/positionupdate"
	API_PATH_USER_UPDATE_STATE   string = "/cgi/user/enable/stateupdate" //修改用户激活状态
	API_PATH_USER_UPDATE_QUIT    string = "/cgi/user/quit"               //用户离职
	API_PATH_USER_UPDATE_RESTORE string = "/cgi/user/restore"            //用户复职
	API_PATH_USER_DELETE         string = "/cgi/user/delete"
	API_PATH_USER_INFO           string = "/cgi/user/get"
	API_PATH_DEPT_USERS          string = "/cgi/user/simplelist" //获取部门用户
)

// 创建用户(好像有bug: userid 如果已经存在,会被覆盖,但名字没覆盖掉)
func (c *Org) UserCreate(data model.UserInfo) error {
	api := API_PATH_USER_CREATE

	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, data)

	return err
}

// 修改用户资料，model.UserInfo 中的 EnableState 不能用
func (c *Org) UserUpdate(data model.UserInfo) error {
	api := API_PATH_USER_UPDATE
	// 检查用户Id是否为空
	if data.UserId == "" {
		return fmt.Errorf("用户ID不能为空")
	}
	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, data)
	return err
}

// 更新用户部门职务信息
func (c *Org) UserUpdatePos(data model.UserInfoPos) error {
	api := API_PATH_USER_UPDATE_POS
	// 检查用户Id是否为空
	if data.UserID == "" {
		return fmt.Errorf("用户ID不能为空")
	}
	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, data)
	return err
}

// 删除用户
func (c *Org) UserDelete(id string) error {
	api := fmt.Sprintf("%s?userId=%s", API_PATH_USER_DELETE, id)
	// 检查部门ID是否大于0
	if id == "" {
		return fmt.Errorf("用户ID不能为空")
	}
	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, nil)
	return err
}

// 获取用户资料
func (c *Org) UserInfoGet(id string) (*model.UserInfo, error) {
	api := fmt.Sprintf("%s?userId=%s", API_PATH_USER_INFO, id)
	var userInfo model.UserInfo

	resp, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, nil)
	if err != nil {
		return nil, err
	}

	if err := json.Unmarshal(resp, &userInfo); err != nil {
		return nil, err
	}

	return &userInfo, nil
}

// 获取用户资料
func (c *Org) DeptUsersListGet(deptId string) (*model.DepartmentUserList, error) {
	api := fmt.Sprintf("%s?deptId=%s", API_PATH_DEPT_USERS, deptId)
	var userList model.DepartmentUserList

	resp, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, nil)
	if err != nil {
		return nil, err
	}

	if err := json.Unmarshal(resp, &userList); err != nil {
		return nil, err
	}

	return &userList, nil
}

// 更新用户激活状态,支持多个用户,用户状态（-1：禁用，1：已授权，0：未激活）
func (c *Org) UserUpdateState(state int, userIds ...string) error {
	api := API_PATH_USER_UPDATE_STATE
	// 检查用户Id是否为空
	if len(userIds) == 0 {
		return fmt.Errorf("用户ID不能为空")
	}
	/*
		{
			"userIdList": ["user1", "user2"],
			"enableState": -1
		}
	*/
	//使用上面的数据,参考,创建 data 数据结构
	data := struct {
		UserIdList  []string `json:"userIdList"`
		EnableState int      `json:"enableState"`
	}{
		UserIdList:  userIds,
		EnableState: state,
	}

	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, data)
	return err
}

// 用户离职,支持多个用户 ,最多支持1000个
func (c *Org) UserQuit(buin int, userIds ...string) error {
	api := API_PATH_USER_UPDATE_QUIT
	// 检查用户Id是否为空
	if len(userIds) == 0 {
		return fmt.Errorf("用户ID不能为空")
	}
	data := struct {
		AccList []string `json:"accList"`
		Buin    int      `json:"buin"`
	}{
		AccList: userIds,
		Buin:    buin,
	}

	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, data)
	return err
}

// 用户复职,成员账号, 与 gid 二选一 （服务端版本要求 >=v2023.3.1，低版本请联系技术支持
func (c *Org) UserRestore(buin int, gid int, userId string) error {
	api := API_PATH_USER_UPDATE_RESTORE
	// 检查用户Id是否为空
	if userId == "" && gid == 0 {
		return fmt.Errorf("用户ID和Gid不能同时为空")
	}
	data := struct {
		Buin    int    `json:"buin"`
		Account string `json:"account,omitempty"`
		Gid     int    `json:"gid,omitempty"`
	}{
		Buin: buin,
	}
	if gid == 0 {
		data.Account = userId
	} else {
		data.Gid = gid
	}
	_, err := Tools.ApiRequest(c.Server, c.Buin, c.AppId, c.EncodedAesKey, api, data)
	return err
}

/************************************************************/
func (c *Org) UserSave(user model.UserInfo) error {
	// 查询用户是否已经存在
	if _, err := c.UserInfoGet(user.UserId); err == nil {
		if err := c.UserUpdate(user); err != nil {
			return fmt.Errorf("更新用户资料失败：%s", err.Error())
		}
		// resState := "(状态已更新)"
		if err := c.UserUpdateState(user.EnableState, user.UserId); err != nil {
			// resState = "(状态未更新)"
		}
		// vidii.ResponsePack(c, 0, "更新用户成功："+ydUser.UserId+resState)
	} else {
		// 创建用户
		if err := c.UserCreate(user); err != nil {
			return fmt.Errorf("创建用户失败: %s", err.Error())
		}
	}
	return nil
}

// DeptClear 递归清空部门及其子部门下的所有成员，并删除部门
func (c *Org) DeptClear(deptId int) error {
	// 获取部门列表
	deptList, err := c.DepartmentListGet(deptId)
	if err != nil {
		return fmt.Errorf("获取部门列表失败: %v", err)
	}

	// 遍历部门列表
	for _, dept := range deptList.DeptList {
		// 获取当前部门下的用户列表
		userList, err := c.DeptUsersListGet(fmt.Sprintf("%d", dept.Id))
		if err != nil {
			return fmt.Errorf("获取部门[%d]用户列表失败: %v", dept.Id, err)
		}

		// 删除当前部门下的所有用户
		for _, user := range userList.UserList {
			if err := c.UserDelete(user.UserID); err != nil {
				return fmt.Errorf("删除用户[%s]失败: %v", user.UserID, err)
			}
			fmt.Printf("删除用户[%s]成功\n", user.UserID)
		}

		// 递归处理子部门，除了id为0的根部门，和当前部门
		if dept.Id != 0 {
			if dept.Id == deptId {
				fmt.Printf("等待删除部门[%d]\n", dept.Id)
				continue
			}
			if err := c.DeptClear(dept.Id); err != nil {
				return err
			}
		}

		// 删除当前部门，除了id为0的根部门
		if deptId != 0 {
			if err := c.DepartmentDelete(dept.Id); err != nil {
				return fmt.Errorf("删除部门[%d]失败: %v", dept.Id, err)
			}
			fmt.Printf("删除部门[%d]成功\n", dept.Id)
		}

	}

	return nil
}
